{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:16.809039Z",
     "start_time": "2025-02-07T01:33:16.804478Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.6.0+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 加载数据",
   "id": "92a19dd204058cd"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:16.879555Z",
     "start_time": "2025-02-07T01:33:16.846325Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)"
   ],
   "id": "5b2bfa747663d0a0",
   "outputs": [],
   "execution_count": 6
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:19.565573Z",
     "start_time": "2025-02-07T01:33:16.880558Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:  # 遍历每张图片,img.shape=[1,28,28]\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2860], [0.3205])  # 这里的均值和标准差是通过train_ds计算得到的\n",
    ")\n"
   ],
   "id": "a53fcd4642407473",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0.2860]), tensor([0.3205]))\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 定义模型\n",
    "这里没有用`nn.Linear`的默认初始化，而是采用了xavier均匀分布去初始化全连接层的权重\n",
    "\n",
    "xavier初始化出自论文 《Understanding the difficulty of training deep feedforward neural networks》，适用于使用`tanh`和`sigmoid`激活函数的方法。当然，这里的模型采用的是`relu`激活函数，采用He初始化（何凯明初始化）会更加合适。\n",
    "\n",
    "|神经网络层数|初始化方式|early stop at epoch| val_loss | vla_acc|\n",
    "|-|-|-|-|-|\n",
    "|20|默认|\n",
    "|20|xaviier_uniform|\n",
    "|20|he_uniform|\n",
    "|...|\n",
    "\n",
    "He初始化出自论文 《Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》"
   ],
   "id": "64bf59205d3cfa1f"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:19.577163Z",
     "start_time": "2025-02-07T01:33:19.566577Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 NeuralNetwork 的类，继承自 nn.Module\n",
    "# 继承 nn.Module 可以使用 PyTorch 提供的神经网络功能\n",
    "class NeuralNetwork(nn.Module):\n",
    "\n",
    "    # 定义类的构造函数，接受一个参数 layers_num，表示隐藏层的数量，默认值为 2。\n",
    "    # 初始化网络的层结构和参数\n",
    "    def __init__(self, layers_num=2):\n",
    "\n",
    "        # 调用父类的构造函数\n",
    "        # 确保 NeuralNetwork 类正确初始化\n",
    "        super().__init__()\n",
    "\n",
    "        # 将 transforms 赋值给类的属性 self.transforms\n",
    "        self.transforms = transforms\n",
    "\n",
    "        # 定义一个 Flatten 层，用于将输入数据展平为一维向量\n",
    "        self.flatten = nn.Flatten()\n",
    "\n",
    "        # 定义一个 Sequential 容器，包含一个全连接层和一个 ReLU 激活函数\n",
    "        # 构建网络的第一层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "\n",
    "        # 循环添加隐藏层，每层包括一个全连接层和一个 ReLU 激活函数\n",
    "        # 动态构建隐藏层，使网络深度可配置\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"relu\", nn.ReLU())\n",
    "\n",
    "        # 定义输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "\n",
    "        # 调用 init_weights 方法初始化网络参数\n",
    "        # 避免参数初始值不合适导致训练困难\n",
    "        self.init_weights()\n",
    "\n",
    "        # 定义 init_weights 方法，用于初始化网络参数\n",
    "        # self.modules(): 获取网络中的所有模块\n",
    "        # isinstance(m, nn.Linear): 检查模块是否为全连接层。\n",
    "        # nn.init.xavier_uniform_(m.weight): 使用 Xavier 初始化方法初始化权重。\n",
    "        # nn.init.zeros_(m.bias): 将偏置初始化为 0。\n",
    "        # 合适的参数初始化可以加速模型收敛\n",
    "\n",
    "    def init_weights(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "        # 定义 forward 方法，实现网络的前向传播\n",
    "        # 输入数据经过 transforms 处理后，经过 flatten 层展平为一维向量\n",
    "        # 经过 linear_relu_stack 层，输出网络预测结果\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.transforms(x)\n",
    "        x = self.flatten(x)\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        return logits\n",
    "\n",
    "\n",
    "# 计算并打印模型的参数数量和形状\n",
    "# NeuralNetwork(20).named_parameters(): 获取模型的所有参数及其名称。\n",
    "# np.prod(value.shape): 计算参数的个数（形状的乘积）。\n",
    "# total += np.prod(value.shape): 累加所有参数的数量。\n",
    "total = 0\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\")\n",
    "    print(f\"Linear_{idx // 2:>02}\\tshape: {value.shape}\")\n",
    "    total += np.prod(value.shape)\n",
    "total"
   ],
   "id": "2bfa7060ce08fe71",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear_00\tparamerters num: 78400\n",
      "Linear_00\tshape: torch.Size([100, 784])\n",
      "Linear_00\tparamerters num: 100\n",
      "Linear_00\tshape: torch.Size([100])\n",
      "Linear_01\tparamerters num: 10000\n",
      "Linear_01\tshape: torch.Size([100, 100])\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_01\tshape: torch.Size([100])\n",
      "Linear_02\tparamerters num: 10000\n",
      "Linear_02\tshape: torch.Size([100, 100])\n",
      "Linear_02\tparamerters num: 100\n",
      "Linear_02\tshape: torch.Size([100])\n",
      "Linear_03\tparamerters num: 10000\n",
      "Linear_03\tshape: torch.Size([100, 100])\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_03\tshape: torch.Size([100])\n",
      "Linear_04\tparamerters num: 10000\n",
      "Linear_04\tshape: torch.Size([100, 100])\n",
      "Linear_04\tparamerters num: 100\n",
      "Linear_04\tshape: torch.Size([100])\n",
      "Linear_05\tparamerters num: 10000\n",
      "Linear_05\tshape: torch.Size([100, 100])\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_05\tshape: torch.Size([100])\n",
      "Linear_06\tparamerters num: 10000\n",
      "Linear_06\tshape: torch.Size([100, 100])\n",
      "Linear_06\tparamerters num: 100\n",
      "Linear_06\tshape: torch.Size([100])\n",
      "Linear_07\tparamerters num: 10000\n",
      "Linear_07\tshape: torch.Size([100, 100])\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_07\tshape: torch.Size([100])\n",
      "Linear_08\tparamerters num: 10000\n",
      "Linear_08\tshape: torch.Size([100, 100])\n",
      "Linear_08\tparamerters num: 100\n",
      "Linear_08\tshape: torch.Size([100])\n",
      "Linear_09\tparamerters num: 10000\n",
      "Linear_09\tshape: torch.Size([100, 100])\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_09\tshape: torch.Size([100])\n",
      "Linear_10\tparamerters num: 10000\n",
      "Linear_10\tshape: torch.Size([100, 100])\n",
      "Linear_10\tparamerters num: 100\n",
      "Linear_10\tshape: torch.Size([100])\n",
      "Linear_11\tparamerters num: 10000\n",
      "Linear_11\tshape: torch.Size([100, 100])\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_11\tshape: torch.Size([100])\n",
      "Linear_12\tparamerters num: 10000\n",
      "Linear_12\tshape: torch.Size([100, 100])\n",
      "Linear_12\tparamerters num: 100\n",
      "Linear_12\tshape: torch.Size([100])\n",
      "Linear_13\tparamerters num: 10000\n",
      "Linear_13\tshape: torch.Size([100, 100])\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_13\tshape: torch.Size([100])\n",
      "Linear_14\tparamerters num: 10000\n",
      "Linear_14\tshape: torch.Size([100, 100])\n",
      "Linear_14\tparamerters num: 100\n",
      "Linear_14\tshape: torch.Size([100])\n",
      "Linear_15\tparamerters num: 10000\n",
      "Linear_15\tshape: torch.Size([100, 100])\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_15\tshape: torch.Size([100])\n",
      "Linear_16\tparamerters num: 10000\n",
      "Linear_16\tshape: torch.Size([100, 100])\n",
      "Linear_16\tparamerters num: 100\n",
      "Linear_16\tshape: torch.Size([100])\n",
      "Linear_17\tparamerters num: 10000\n",
      "Linear_17\tshape: torch.Size([100, 100])\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_17\tshape: torch.Size([100])\n",
      "Linear_18\tparamerters num: 10000\n",
      "Linear_18\tshape: torch.Size([100, 100])\n",
      "Linear_18\tparamerters num: 100\n",
      "Linear_18\tshape: torch.Size([100])\n",
      "Linear_19\tparamerters num: 10000\n",
      "Linear_19\tshape: torch.Size([100, 100])\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_19\tshape: torch.Size([100])\n",
      "Linear_20\tparamerters num: 1000\n",
      "Linear_20\tshape: torch.Size([10, 100])\n",
      "Linear_20\tparamerters num: 10\n",
      "Linear_20\tshape: torch.Size([10])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "271410"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 训练",
   "id": "d911b185989182f4"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:19.644062Z",
     "start_time": "2025-02-07T01:33:19.578508Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "# 这是一个装饰器，用于禁用梯度计算。\n",
    "# 在评估模型时，我们不需要计算梯度，因为不会进行反向传播和参数更新。禁用梯度计算可以减少内存消耗并加速计算。\n",
    "@torch.no_grad()\n",
    "# 定义评估函数，接受三个参数：model（要评估的模型）、dataloader（数据加载器，用于提供评估数据）、loss_fct（损失函数）。\n",
    "# 用于评估模型在给定数据集上的性能。\n",
    "# 通过封装评估过程，可以方便地在不同模型和数据集上重复使用。\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    # 初始化三个空列表，分别用于存储每个批次的损失、预测标签和真实标签。\n",
    "    # 用于累积所有批次的损失和标签，以便后续计算平均损失和准确率。\n",
    "    # 累积所有批次的结果可以更准确地反映模型在整个数据集上的性能。\n",
    "    loss_list = []  # 记录损失\n",
    "    pred_list = []  # 记录预测\n",
    "    label_list = []  # 记录标签\n",
    "\n",
    "    # 遍历数据加载器中的每个批次，datas 是输入数据，labels 是对应的真实标签\n",
    "    for datas, labels in dataloader:\n",
    "        # 将输入数据和标签移动到指定的设备（GPU或CPU），转到GPU可以加速计算\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # 将输入数据传递给模型，得到模型的输出 logits（通常是未归一化的预测分数）。\n",
    "        # 模型的前向传播过程，计算输入数据对应的输出。通过模型的输出可以计算损失和预测标签。\n",
    "        logits = model(datas)\n",
    "\n",
    "        # 将当前批次的损失值（转换为 Python 浮点数）添加到 loss_list 中。\n",
    "        # loss.item() 将张量中的单个值提取为 Python 浮点数。\n",
    "        # 累积所有批次的损失值，以便后续计算平均损失。\n",
    "        loss = loss_fct(logits, labels)\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        # 通过 argmax 函数获取模型预测的类别标签。axis=-1 表示在最后一个维度上取最大值对应的索引。\n",
    "        # logits 通常是每个类别的分数，argmax 找到分数最高的类别作为预测结果。\n",
    "        # 将模型的输出转换为具体的类别标签，便于与真实标签进行比较。\n",
    "        preds = logits.argmax(axis=-1)\n",
    "\n",
    "        # 将预测标签从 GPU 移动到 CPU，并转换为 NumPy 数组，再转换为 Python 列表，然后添加到 pred_list 中。\n",
    "        # preds.cpu().numpy().tolist() 将张量转换为 Python 列表。\n",
    "        # 累积所有批次的预测标签，以便后续计算准确率。\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    #计算预测标签和真实标签之间的准确率\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "\n",
    "    #返回所有批次的平均损失和准确率。\n",
    "    return np.mean(loss_list), acc"
   ],
   "id": "f61f638900a4b1f3",
   "outputs": [],
   "execution_count": 9
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Tensorboard 可视化",
   "id": "bf15f06c65aecdc5"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:22.239672Z",
     "start_time": "2025-02-07T01:33:19.644062Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir,\n",
    "                                    flush_secs=flush_secs)  # 实例化SummaryWriter, log_dir是log存放路径，flush_secs是每隔多少秒写入磁盘\n",
    "\n",
    "    def draw_model(self, model, input_shape):  #graphs\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))  # 画模型图\n",
    "\n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\",\n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "        )  # 画loss曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )  # 画acc曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "        )  # 画lr曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss,把loss，val_loss取掉，画loss曲线\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)  # 画loss曲线\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)  # 画acc曲线\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)  # 画lr曲线\n"
   ],
   "id": "8c2df3129dcef4b6",
   "outputs": [],
   "execution_count": 10
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### 保存最好模型",
   "id": "e90b3a3c89900c08"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:22.245677Z",
     "start_time": "2025-02-07T01:33:22.240677Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 SaveCheckpointsCallback 的类。\n",
    "# 该类用于在训练过程中保存模型的检查点。封装保存检查点的逻辑，方便在训练过程中调用\n",
    "class SaveCheckpointsCallback:\n",
    "    \"\"\"\n",
    "    Callback to save model checkpoints during training.\n",
    "    \"\"\"\n",
    "\n",
    "    #定义类的构造函数，接受以下参数：\n",
    "    # save_dir: 检查点保存的目录。\n",
    "    # save_step: 每隔多少步保存一次检查点，默认值为 500。\n",
    "    # save_best_only: 是否只保存性能最好的检查点，默认值为 True\n",
    "    # 原理：初始化回调类的参数和状态\n",
    "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
    "\n",
    "        # 将传入的参数保存为类的属性\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "\n",
    "        # 初始化一个变量 best_metrics，用于记录当前最好的性能指标值，初始值为 -1\n",
    "        # 原理: 用于比较当前模型的性能是否优于之前保存的模型,当 save_best_only 为 True 时，只保存性能最好的模型\n",
    "        self.best_metrics = -1\n",
    "\n",
    "        # 检查保存目录是否存在，如果不存在则创建该目录\n",
    "        # os.path.exists()用于判断路径是否存在, os.mkdir()用于创建目录\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "\n",
    "    # 定义 __call__ 方法，使类的实例可以像函数一样调用。参数包括：\n",
    "    # step: 当前训练的步数。\n",
    "    # state_dict: 模型的状态字典（包含模型参数）。\n",
    "    # metric: 当前模型的性能指标值（如验证集准确率），默认为 None\n",
    "    # 在训练过程中定期调用该方法，保存检查点\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "\n",
    "        # 检查当前步数是否是 save_step 的倍数，如果不是则直接返回\n",
    "        # 控制保存检查点的频率，避免频繁保存\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "\n",
    "        # 检查是否只保存性能最好的检查点\n",
    "        # 根据 save_best_only 的值决定保存策略,提供两种保存策略：定期保存和只保存最佳模型\n",
    "        if self.save_best_only:\n",
    "\n",
    "            # 如果 save_best_only 为 True，则要求 metric 不能为 None。\n",
    "            # 原理: 使用 assert 断言确保 metric 有值。如果 metric 为 None，无法判断模型性能是否更好，因此需要提前检查\n",
    "            assert metric is not None\n",
    "\n",
    "            # 检查当前模型的性能指标是否优于之前保存的最佳模型\n",
    "            # 只保存性能更好的模型，避免保存性能下降的模型\n",
    "            if metric >= self.best_metrics:\n",
    "                # 将模型的状态字典保存到指定目录下的 best.ckpt 文件中\n",
    "                # 使用 torch.save 保存模型参数。保存当前性能最好的模型，方便后续加载和使用\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "\n",
    "                # 更新 best_metrics 为当前模型的性能指标值\n",
    "                self.best_metrics = metric\n",
    "\n",
    "        # 如果 save_best_only 为 False，则执行以下逻辑\n",
    "        # 定期保存检查点，不关心模型性能是否更好\n",
    "        else:\n",
    "\n",
    "            # 将模型的状态字典保存到指定目录下，文件名为当前步数\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))"
   ],
   "id": "a6f18fc340403b57",
   "outputs": [],
   "execution_count": 11
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### 早停",
   "id": "4720c83f1ce2c823"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:22.249678Z",
     "start_time": "2025-02-07T01:33:22.246180Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 EarlyStopCallback 的类.用于监控模型在验证集上的性能，并在性能不再提升时触发早停。\n",
    "# 封装早停的逻辑，方便在训练过程中调用\n",
    "class EarlyStopCallback:\n",
    "\n",
    "    # 定义类的构造函数，接受以下参数\n",
    "    # patience: 容忍的轮次数，默认值为 5。如果在 patience 轮内性能没有提升，则触发早停。\n",
    "    # min_delta: 性能提升的最小阈值，默认值为 0.01。只有当性能提升超过该阈值时，才认为模型有改进。\n",
    "    # 初始化早停回调的参数和状态\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "\n",
    "        # 将传入的参数保存为类的属性\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "\n",
    "        self.best_metric = -1  # 用于比较当前模型的性能是否优于之前的最佳性能\n",
    "\n",
    "        # 初始化一个计数器 counter，用于记录性能没有提升的连续轮次数，初始值为 0\n",
    "        # 当性能没有提升时，计数器增加；当性能提升时，计数器重置,用于判断是否达到了早停的条件\n",
    "        self.counter = 0\n",
    "\n",
    "    # 训练过程中定期调用该方法，更新早停状态\n",
    "    def __call__(self, metric):\n",
    "\n",
    "        # 检查当前性能指标是否比之前的最佳性能提升了至少 min_delta\n",
    "        # 避免微小的波动触发早停,当性能有显著提升时，才认为模型有改进\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "\n",
    "            self.best_metric = metric  # 记录当前最佳性能\n",
    "            self.counter = 0  # 性能有提升时，重置计数器,重新开始计算性能没有提升的连续轮次数\n",
    "\n",
    "        # 性能没有提升时，增加计数器\n",
    "        else:\n",
    "            self.counter += 1  # 记录性能没有提升的连续轮次数\n",
    "\n",
    "    # 定义一个只读属性 early_stop，用于判断是否触发早停。\n",
    "    # 使用 @property 装饰器将方法转换为属性。方便外部代码通过属性访问早停状态。\n",
    "    @property\n",
    "    def early_stop(self):\n",
    "\n",
    "        # 检查计数器 counter 是否大于或等于 patience\n",
    "        # 提供早停的触发条件\n",
    "        return self.counter >= self.patience"
   ],
   "id": "4d832bdbea1d7eec",
   "outputs": [],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:22.257092Z",
     "start_time": "2025-02-07T01:33:22.250683Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 training 的函数，用于训练模型。参数包括：\n",
    "# model: 要训练的模型。\n",
    "# train_loader: 训练数据的数据加载器。\n",
    "# val_loader: 验证数据的数据加载器。\n",
    "# epoch: 训练的轮数。\n",
    "# loss_fct: 损失函数。\n",
    "# optimizer: 优化器。\n",
    "# eval_step: 每隔多少步评估一次验证集性能，默认值为 500。\n",
    "# 该函数通过遍历训练数据，更新模型参数，并定期评估验证集性能。封装训练过程，方便重复使用\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_fct,\n",
    "        optimizer,\n",
    "        tensorboard_callback=None,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    # 初始化一个字典 record_dict，用于记录训练和验证过程中的损失和准确率。\n",
    "    # 通过记录训练和验证的性能，可以分析模型的训练过程。方便后续绘制训练曲线或分析模型表现。\n",
    "    record_dict = {\n",
    "        \"train\": [],  # \"train\": 存储训练集的损失和准确率。\n",
    "        \"val\": []  # \"val\": 存储验证集的损失和准确率。\n",
    "    }\n",
    "\n",
    "    # 初始化一个全局步数计数器 global_step，用于记录当前训练的步数。\n",
    "    # 步数用于控制何时评估验证集性能。通过步数而不是轮数来控制评估频率，更灵活。\n",
    "    global_step = 0\n",
    "\n",
    "    # 将模型设置为训练模式。在训练模式下，模型会启用一些特定于训练的功能（如 Dropout 和 BatchNorm）。\n",
    "    # 确保模型在训练时行为正确。\n",
    "    model.train()\n",
    "\n",
    "    # 使用 tqdm 创建一个进度条，总长度为 epoch * len(train_loader)，即总训练步数。\n",
    "    # tqdm 是一个进度条库，用于显示训练进度。\n",
    "    # 提供可视化的训练进度，方便监控训练过程。\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "\n",
    "        # 外层循环，遍历每个训练轮次。每个轮次会遍历整个训练数据集一次。\n",
    "        # 多轮训练可以提高模型的性能。\n",
    "        for epoch_id in range(epoch):\n",
    "\n",
    "            # 内层循环，遍历训练数据加载器中的每个批次。\n",
    "            for datas, labels in train_loader:\n",
    "\n",
    "                # 将输入数据和标签移动到指定的设备（GPU或CPU），转到GPU可以加速计算\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                # 清除优化器中之前的梯度。\n",
    "                # PyTorch 会累积梯度，因此在每次反向传播前需要清除之前的梯度。避免梯度累积导致错误的参数更新。\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "                logits = model(datas)  # 模型前向计算\n",
    "                loss = loss_fct(logits, labels)  # 计算损失\n",
    "\n",
    "                # 计算损失相对于模型参数的梯度。\n",
    "                # 反向传播算法，通过链式法则计算梯度。梯度用于更新模型参数，以最小化损失。\n",
    "                loss.backward()\n",
    "\n",
    "                # 使用优化器更新模型参数。\n",
    "                optimizer.step()\n",
    "\n",
    "                preds = logits.argmax(axis=-1)  # 通过 argmax 函数获取模型预测的类别标签。\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())  # 计算当前批次的准确率\n",
    "                loss = loss.cpu().item()  # 将损失值从 GPU 移动到 CPU，并转换为 Python 浮点数。方便记录和打印损失值。\n",
    "\n",
    "                # 将当前批次的损失、准确率和步数记录到 record_dict[\"train\"] 中\n",
    "                # 累积训练过程中的性能指标。方便后续分析训练过程\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # 每隔 eval_step 步评估一次验证集性能。\n",
    "                # 使用 global_step 控制评估频率。定期评估验证集性能，避免过拟合。\n",
    "                if global_step % eval_step == 0:\n",
    "                    # 将模型设置为评估模式\n",
    "                    model.eval()\n",
    "\n",
    "                    # 调用 evaluating 函数计算验证集的损失和准确率\n",
    "                    # 在验证集上评估模型性能。验证集性能反映了模型的泛化能力。\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "\n",
    "                    # 将验证集的损失、准确率和步数记录到 record_dict[\"val\"] 中。\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "\n",
    "                    # 将模型设置为训练模式\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        # 调用 tensorboard 回调函数，记录训练过程中的关键指标\n",
    "                        tensorboard_callback(\n",
    "                            global_step,  # 当前训练的全局步数，用于在 TensorBoard 中标识不同的训练阶段\n",
    "                            loss=loss, val_loss=val_loss,  # 记录训练集和验证集的损失值，用于监控模型在训练和验证集上的表现\n",
    "                            acc=acc, val_acc=val_acc,  # 记录训练集和验证集的准确率，用于监控模型的分类性能\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],  # 取出当前学习率，用于监控学习率的变化，确保学习率调整策略正常工作\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        # 调用保存模型权重的回调函数，保存当前模型的权重\n",
    "                        save_ckpt_callback(\n",
    "                            global_step,  # 当前训练的全局步数，用于标识保存的模型权重对应的训练阶段\n",
    "                            model.state_dict(),  # 保存模型的当前状态字典（即模型的所有参数），以便后续可以恢复模型\n",
    "                            metric=val_acc  # 使用验证集的准确率作为指标，判断是否保存当前模型（通常只保存性能最好的模型）\n",
    "                        )\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        # 调用早停回调函数，监控验证集准确率是否不再提升\n",
    "                        early_stop_callback(val_acc)  # 传入验证集准确率，用于判断是否满足早停条件\n",
    "                        if early_stop_callback.early_stop:  # 检查是否触发了早停条件\n",
    "                            # 如果触发了早停条件，打印提示信息并结束训练\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict  # 返回训练记录字典，包含训练过程中的关键指标\n",
    "\n",
    "                # 增加全局步数计数器\n",
    "                # 记录当前训练的步数,控制评估频率和记录训练进度\n",
    "                global_step += 1\n",
    "\n",
    "                # 更新进度条\n",
    "                pbar.update(1)\n",
    "\n",
    "                # 在进度条中显示当前训练的轮次。\n",
    "                # 更新进度条的后缀信息。方便监控训练进度。\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    # 返回记录的训练和验证性能的字典,包含训练和验证过程中的损失和准确率\n",
    "    return record_dict"
   ],
   "id": "a452d95c803a8a58",
   "outputs": [],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:22.343078Z",
     "start_time": "2025-02-07T01:33:22.258096Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 100\n",
    "\n",
    "# 实例化NeuralNetwork类，创建一个神经网络模型对象\n",
    "model = NeuralNetwork(layers_num=10)\n",
    "\n",
    "# 定义了一个损失函数使用的是交叉熵损失函数，这是分类问题中常用的损失函数。\n",
    "# CrossEntropyLoss 结合了 Softmax 激活函数和 Log Loss，内部先做softmax，再计算交叉熵，用于多类别分类问题。\n",
    "# 输入是未经过 Softmax 处理的 logits（原始预测分数），而目标标签应该是类别的索引\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "\n",
    "# 优化器：用于更新模型的参数。\n",
    "# 这里使用的是 SGD（随机梯度下降，Stochastic Gradient Descent）优化算法。通过对每个数据点的梯度进行更新，快速地调整模型参数。\n",
    "# model.parameters()：这一部分是传入模型的所有参数，优化器将会基于这些参数计算梯度并进行更新。\n",
    "# lr：学习率，控制参数更新的步长。学习率越小，更新越慢；学习率越大，可能会导致训练不稳定。0.001 是一个比较常见的初始学习率。\n",
    "# momentum：动量是为了加速 SGD，避免在训练过程中振荡。动量值通常在 0 到 1 之间，0.9 是一个常用的选择。动量帮助优化器在上一次梯度的方向上继续前进，从而使得优化过程更为稳定。\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 实例化\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. 保存最佳模型\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints\", save_best_only=True)\n",
    "# 3. 早停\n",
    "early_stop_callback = EarlyStopCallback(patience=10)"
   ],
   "id": "55fd51912633ca11",
   "outputs": [],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:42:51.105163Z",
     "start_time": "2025-02-07T01:33:22.344082Z"
    }
   },
   "cell_type": "code",
   "source": [
    "record = training(\n",
    "    model,  # 要训练的模型\n",
    "    train_loader,  # 训练数据的数据加载器\n",
    "    val_loader,  # 验证数据的数据加载器\n",
    "    epoch,  # 训练的轮数\n",
    "    loss_fct,  # 损失函数\n",
    "    optimizer,  # 优化器\n",
    "    tensorboard_callback=None,  # tensorboard 可视化\n",
    "    save_ckpt_callback=save_ckpt_callback,  # 保存最佳模型\n",
    "    early_stop_callback=early_stop_callback,  # 早停\n",
    "    eval_step=len(train_loader)  # 每隔多少步评估一次验证集性能\n",
    ")"
   ],
   "id": "a715ad4ee2ef44c8",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "80f8aaed825f43b6a9e1e10b6b65ab95"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 14 / global_step 52500\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:42:51.280201Z",
     "start_time": "2025-02-07T01:42:51.106167Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "# 定义一个名为 plot_learning_curves 的函数，接受以下参数：\n",
    "# record_dict: 包含训练和验证记录的字典。\n",
    "# sample_step: 对训练数据进行采样的步长，默认值为 500。\n",
    "# 该函数用于可视化训练和验证过程中的性能指标。\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # 将训练记录转换为 Pandas DataFrame，并设置 step 列为索引。然后对数据进行采样，步长为 sample_step\n",
    "    # pd.DataFrame(record_dict[\"train\"]): 将训练记录转换为 DataFrame。\n",
    "    # .set_index(\"step\"): 将 step 列设置为索引。\n",
    "    # .iloc[::sample_step]: 对数据进行采样，每隔 sample_step 步取一个样本。\n",
    "    # 减少数据点的数量，使曲线更清晰，同时保留趋势\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "\n",
    "    # 将验证记录转换为 Pandas DataFrame，并设置 step 列为索引\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # 计算训练 DataFrame 的列数，即需要绘制的性能指标数量\n",
    "    # 确定需要创建的子图数量\n",
    "    fig_num = len(train_df.columns)\n",
    "\n",
    "    # 创建一个包含 fig_num 个子图的图形\n",
    "    # 为每个性能指标创建一个子图，方便对比\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "\n",
    "    # 遍历训练 DataFrame 的每一列（即每个性能指标）。\n",
    "    # 使用 enumerate 获取列名和索引\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        # train_df.index: x 轴数据（训练步数）。\n",
    "        # train_df[item]: y 轴数据（性能指标值）。\n",
    "        # label=f\"train_{item}\": 设置曲线的标签。\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "\n",
    "        axs[idx].grid()  # 在当前子图上添加网格线\n",
    "        axs[idx].legend()  # 在当前子图上添加图例\n",
    "\n",
    "        # 生成 x 轴的刻度数据，从 0 到最大步数，步长为 5000\n",
    "        x_data = range(0, train_df.index[-1], 5000)\n",
    "\n",
    "        axs[idx].set_xticks(x_data)  # 设置 x 轴的刻度位置\n",
    "\n",
    "        # 设置 x 轴的刻度标签，将步数转换为“k”格式（如 5000 → \"5k\"）\n",
    "        # map(lambda x: f\"{int(x / 1000)}k\", x_data): 将刻度数据转换为“k”格式。\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x / 1000)}k\", x_data))\n",
    "\n",
    "        axs[idx].set_xlabel(\"step\")  # 设置 x 轴的标签为“step”\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)"
   ],
   "id": "a74c32989540c34",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:43:01.823242Z",
     "start_time": "2025-02-07T01:42:51.281295Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "id": "c20bcbde0c67ab40",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3703\n",
      "accuracy: 0.8787\n"
     ]
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:43:01.826248Z",
     "start_time": "2025-02-07T01:43:01.824247Z"
    }
   },
   "cell_type": "code",
   "source": "",
   "id": "4a62054811a449ea",
   "outputs": [],
   "execution_count": 17
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
